<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        let arr = ['张飞', '关羽', '赵子龙', '黄忠', '马超']
        // for (let i = 0; i < arr.length; i++) {
        //     const element = arr[i];
        //     console.log(element);
        // }

        // for (const item of arr) {
        //     // item 循环遍历数组的元素
        //     console.log(item)
        // }

        // let obj = {
        //     name: 'Tom',
        //     age: 18,
        //     gender: 'Male'
        // };
        // for (const key in obj) {
        //     console.log('元素key值：' + obj[key]);
        // }

        // for (const key in arr) {
        //     if (Object.prototype.hasOwnProperty.call(arr, key)) {
        //         const element = arr[key];
        //         console.log(element);
        //     }
        // }


        //array.forEach(function (currentValue, index, array) {
        // currentValue 遍历出的每一个元素
        // index 元素对应的下标
        // array 数组本身
        // thisValue 返回值 (也可以不写返回值)
        // 执行内容
        //}, thisValue);

        // let array = [1, 2, 3, 4]
        // array.forEach((item, index, array) => {
        //     // console.log(item);//1 2 3 4
        //     // console.log(index);  元素下标
        //     item = item * 2
        // });
        // console.log(array);[1, 2, 3, 4] //原素组


        // map映射
        // 当前处理的元素值item
        //当前处理的元素索引index
        //当前正在操作的数组对象array
        // let arrnew = [1, 2, 3, 4]
        // let num = arrnew.map((item, index, arrnew) => {
        //     return item * 2;
        // })
        // console.log(num);

        // filter方法
        // let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        // let filternumber = numbers.filter((item, index, arr) => {
        //     // 指定条件
        //     return item >= 5
        // })
        // console.log(filternumber);

        // reduce高阶函数（迭代（累加器））
        // array.reduce(function (accumulator, currentValue, index, array) {
        //     // 累积操作
        // }, initialValue);
        // 累积器(accumulator)
        // 第一个参数是回调函数，它可以接受四个参数：累积器
        // let arrnew = [1, 2, 3, 4, 5];
        // let sum = arrnew.reduce((total,item ) => {
        //     return item + total
        // }, 0)
        // console.log(sum);//累加值15


        // every 遍历数组，每一个元素都满足条件 则返回 true，否则返回 false
        //  arr.every((item, index, arr) => {
        // itme 遍历的每一个元素
        // index 元素对应的下标
        // arr 数组本身
        // 有返回值
        // 检测数组里的值是否满足指定条件，如果有一个值不满足，返回false，剩余的值不再进行检测
        // 如果所有的值都满足，则返回true
        // })

        // some 对数组中每个元素执行一次function 函数，直到某个元素返回true，则直接返回true。如果都返回false,则返回false
        //arr.some((item, index, arr) => {
        // itme 遍历的每一个元素
        // index 元素对应的下标
        // arr 数组本身
        // 有返回值
        // 检测数组里的值是否满足指定条件，如果有一个值不满足，返回false，剩余的值不再进行检测
        // 如果所有的值都满足，则返回true
        // })

        // function sometotal(id) {
        //     const arr = [
        //         { ids: 195, cityName: '深圳' },
        //         { ids: 196, cityName: '北京' },
        //         { ids: 198, cityName: '上海' },
        //     ]
        //     let newsome = arr.some((item) => {
        //         return item.ids === id
        //     })
        //     console.log(`传入${id},结果：${newsome}`);

        // }
        // sometotal(196) //传入196,结果：true


        // find
        // 遍历数组，返回符合条件的第一个元素，如果没有符合条件的元素则返回 undefined
        // let arrfind = [1, 2, 3, 4, 5, 3, 3, 6, 8];
        // let num = arrfind.find((item) => {
        //     return item === 3;
        // })
        // console.log(num);  //3

        // findIndex 方法返回第一个满足这个条件的元素的索引
        // const array = [5, 12, 8, 130, 44];
        // const isLargeNumber = (element) => element > 13;
        // const index = array.findIndex(isLargeNumber);
        // console.log(index); // 输出: 3

        // entries()
        // 方法返回一个迭代器它包含对象自身的（不含继承的）所有可枚举属性的键值对数组。
        // 对于 Map 对象，它返回键值对的迭代器。


        // 对象的 entries() 没有用
        // let obj = { a: 1, b: 2 };
        // for (let [key, value] of obj.entries()) {
        //     console.log(`${key}: ${value}`);
        // }

        // let map = new Map([
        //     ['key1', 'value1'],
        //     ['key2', 'value2']
        // ]);
        // for (let [key, value] of map.entries()) {
        //     console.log(`${key}: ${value}`); // 输出 "key1: value1" 和 "key2: value2"
        // }

        // keys()
        // let obj = { a: 1, b: 2 };
        // // 对象的 keys()
        // for (let key of obj.keys()) {
        //     console.log(key); // 输出 "a" 和 "b"
        // }
        // 注意：Map 对象没有 keys() 方法，因为它的迭代器默认就是返回键。


        // // 对象的 values()
        // let obj = { a: 1, b: 2 };
        // for (let value of obj.values()) {
        //     console.log(value); // 输出 1 和 2
        // }
        // // Map 的 values()
        // let map = new Map([
        //     ['key1', 'value1'],
        //     ['key2', 'value2']
        // ]);

        // for (let value of map.values()) {
        //     console.log(value); // 输出 "value1" 和 "value2"
        // }


        // const arrnew = [
        //     {
        //         name: '青龙偃月刀',
        //         byuse: '关羽',
        //         gongji: 1000
        //     },
        //     {
        //         name: '龙胆亮银枪',
        //         byuse: '赵子龙',
        //         gongji: 2000
        //     },
        //     {
        //         name: '丈八蛇矛',
        //         byuse: '张飞',
        //         gongji: 999
        //     },
        //     {
        //         name: '雌雄对剑',
        //         byuse: '刘备',
        //         gongji: 60
        //     },
        //     {
        //         name: '方天画戟',
        //         byuse: '吕布',
        //         gongji: 999999
        //     },
        // ]

        // // 给所有的武器攻击 * 2  ，还低于1000 淘汰， 把2倍后超过1000武力值加载一起
        // let arrMap = arrnew.map(item => {
        //     return { name: item.name, byuse: item.byuse, gongji: item.gongji * 2 }
        // })
        // console.log(arrMap);
        // let arrfilter = arrMap.filter(item => item.gongji >= 1000)
        // console.log(arrfilter);
        // let arrReduce = arrfilter.reduce((total, item) => total + item.gongji, 0)
        // console.log(arrReduce);

        // // 链式调用
        //返回值是 最后链式调用的函数返回的值
        // let sumgongji = arrnew.map((item) => {
        //     return {
        //         name: item.name,
        //         byuse: item.byuse,
        //         gongji: item.gongji * 2
        //     }
        // }).filter(item => {
        //     return item.gongji >= 1000;
        // }).reduce((leijiaqi, item) => {
        //     return item.gongji + leijiaqi;
        // }, 0)
        // console.log(sumgongji);

        // 过滤数组的奇数
        // const nubers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
        // for (const item of nubers) {
        //     if (item % 2 !== 0) {
        //         console.log(item);
        //     }
        // }

        // const phrases = ['hello world', 'javascript is fun', 'openai gpt', 'coding is great'];
        // for (const item of phrases) {
        //     if (item.includes('is')) {
        //         console.log(item);
        //     }
        // }

        // const person = {
        //     name: 'Alice',
        //     age: 25,
        //     city: 'Wonderland',
        //     occupation: 'Engineer'
        // };
        // for (const key in person) {
        //     if (typeof person[key] === 'string') {
        //         console.log(person[key]);
        //     }
        // }

        // const data = {
        //     a: 10,
        //     b: 20,
        //     c: 'thirty',
        //     d: 40,
        //     e: 'fifty'
        // };
        // let sum = 0
        // for (const key in data) {
        //     if (typeof data[key] === 'number') {
        //         sum += data[key]
        //     }
        // }
        // console.log(sum)

        // const inventory = {
        //     apples: 5,
        //     oranges: 0,
        //     bananas: 8,
        //     grapes: 2,
        //     cherries: 0
        // };
        // for (const key in inventory) {
        //     if (inventory[key] === 0) {
        //         console.log(`${key}:${inventory[key]}`);
        //     }
        // }

        // 查找数组中的字符串长度并输出超过特定长度的字符串
        // const words = ['apple', 'banana', 'cherry', 'date', 'fig', 'grape'];
        // const keys = 5;
        // words.forEach(item => {
        //     if (item.length > keys) {
        //         console.log(item);
        //     }
        // });

        // 将数组中的负数转换为正数
        // const numbers = [-3, 5, -1, 8, -2, 7];
        // let zhuan = numbers.map((item) => {
        //     return item < 0 ? -item : item
        // })
        // console.log(zhuan);

        // 将对象数组中的特定属性值大写化
        // const people = [
        //     { name: 'Alice', age: 25 },
        //     { name: 'Bob', age: 30 },
        //     { name: 'Charlie', age: 35 }
        // ];
        // let toUpp = people.map((item) => {
        //     return item.name.length > 3 ? { name: item.name.toUpperCase(), age: item.age } : item
        // })
        // console.log(toUpp);
        // const uppercasedNames = people.map(person => {
        //     return person.name.length > 3 ? { ...person, name: person.name.toUpperCase() } : person;
        // });

        // console.log(uppercasedNames);

        // 将字符串数组中的特定子字符串替换为另一字符串
        // const phrases = ['hello world', 'javascript is fun', 'hello openai', 'coding is great'];
        // let updata = phrases.map((item) => {
        //     return item.includes('hello') ? item.replace('hello', 'hi') : item
        // })
        // console.log(updata);

        // 计算并输出长度大于 5 的字符串的总长度
        // const phrases = ['hello world', 'javascript', 'openai', 'coding is fun'];
        // const tolength = phrases.filter((item) => {
        //     return item.length > 5; //过滤排除长度小于5的字符串
        // }).map((item) => {
        //     return item.length //返回每个字符串的长度
        // }).reduce((jishu, item) => {
        //     return item + jishu; //计算大于五的总长度
        // }, 0)
        // console.log(tolength);

        // 计算正数数组的平方和，并排除负数
        // const numbers = [-5, 3, -2, 4, 6, -1];
        // const sumbuter = numbers.filter((item) => {
        //     return item > 0;  //过滤
        // }).map((item) => {
        //     return item * item;  //将每一个正数平方
        // }).reduce((jishu, item) => {
        //     return item + jishu;  //最后相加
        // }, 0)
        // console.log(sumbuter);


        // 处理用户数据，提取年龄大于 18 的用户，并计算他们的平均年龄
        // const users = [
        //     { name: 'Alice', age: 22 },
        //     { name: 'Bob', age: 17 },
        //     { name: 'Charlie', age: 30 },
        //     { name: 'David', age: 15 }
        // ];
        // const chennian = users.filter((item) => {
        //     return item.age > 18;
        // }).map((item) => item.age)//把过滤的每一项通过map() 创建一个新的数组
        //     .reduce((jishu, item, index, arrs) => jishu + item / arrs.length, 0)
        // console.log(chennian);

        // 在购物车中移除指定商品
        // const cart = [
        //     { id: 1, name: 'Laptop', quantity: 1 },
        //     { id: 2, name: 'Mouse', quantity: 2 },
        //     { id: 3, name: 'Keyboard', quantity: 1 }
        // ];
        // const itemIdToRemove = 2;
        // const carshoop = cart.findIndex(item => item.id === itemIdToRemove)
        // if (carshoop !== -1) {
        //     cart.splice(carshoop, 1)
        // }
        // console.log(cart);

        // 更新数组中的指定对象属性
        // const employees = [
        //     { id: 1, name: 'John', role: 'Developer' },
        //     { id: 2, name: 'Jane', role: 'Designer' },
        //     { id: 3, name: 'Tom', role: 'Manager' }
        // ];
        // const ments = 3;
        // const newRole = 'Senior Manager';

        // const indexToUpdate = employees.findIndex(item => item.id === ments)
        // if (indexToUpdate !== -1) {
        //     employees[indexToUpdate].role = newRole
        // }
        // console.log(employees);

        // 将数组中的第一个负数替换为零
        // const numbers = [4, -1, 6, -2, 7];
        // const fristfu = numbers.findIndex(item => item < 0)
        // if (fristfu !== -1) {
        //     numbers.splice(fristfu, 1, 0)
        // }
        // console.log(numbers);

        // 正确的对象字面量定义 
        // let obj = { a: 1, b: 2 };

        // // Map 结构 
        // let map = new Map([
        //     ['key1', 'value1'],
        //     ['key2', 'value2']
        // ]);

        // // 对象的遍历 
        // for (let key in obj) {
        //     if (obj.hasOwnProperty(key)) {
        //         console.log(`${key}:  ${obj[key]}`); // 输出 "a: 1" 和 "b: 2"
        //     }
        // }

        // // Map 的遍历 
        // for (let [key, value] of map.entries()) {
        //     console.log(`${key}:  ${value}`); // 输出 "key1: value1" 和 "key2: value2"
        // }

        // let obj = { a: 1, b: 2 };

        // // 对象的 keys()
        // for (let key in obj) {
        //     console.log(key); // 输出 "a" 和 "b"
        // }

        let obj = { a: 1, b: 2 };

        // 对象的 values()
        for (let value in obj) {
            console.log(value); // 输出 1 和 2
        }

        // Map 的 values()
        let map = new Map([
            ['key1', 'value1'],
            ['key2', 'value2']
        ]);

        for (let [key, value] of map) {
            console.log(value); // 输出 "value1" 和 "value2"
        }
    </script>
</body>

</html>